{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:08:40.224873702Z",
     "start_time": "2023-06-05T12:08:40.200942124Z"
    },
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-06-06 13:08:16.287333: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-06-06 13:08:16.863010: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "#this posiibly slows donw my shit significantly\n",
    "# tf.config.run_functions_eagerly(True)\n",
    "import pywt\n",
    "import matplotlib.pyplot as plt\n",
    "import keras\n",
    "from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n",
    "from MyEDFImports import load_all_data, import_ecg, get_edf_filenames, load_all_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:08:47.483346400Z",
     "start_time": "2023-06-05T12:08:40.209394943Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/CP229110.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/WD224010.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/TK221110.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/VP214110.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/CN223100.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/MyEDFImports.py:19: RuntimeWarning: Channel names are not unique, found duplicates for: {'CHIN EMG'}. Applying running numbers for duplicates.\n",
      "  raw = mne.io.read_raw_edf(path + \"//\" + name)\n",
      "/home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/MyEDFImports.py:19: RuntimeWarning: Channel names are not unique, found duplicates for: {'CHIN EMG'}. Applying running numbers for duplicates.\n",
      "  raw = mne.io.read_raw_edf(path + \"//\" + name)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/LM230010.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/VC209100.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/LA216100.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/DG220020.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/DO223050.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "Extracting EDF parameters from /home/tadeusz/Desktop/Tadeusz/mgr_sleep_states/Jean-Pol_repaired_headers/CX230050.edf...\n",
      "EDF file detected\n",
      "Setting channel info structure...\n",
      "Creating raw.info structure...\n",
      "NOTE: pick_channels() is a legacy function. New code should use inst.pick(...).\n",
      "loading file with nr of windows 2007\n",
      "loading file with nr of windows 1777\n",
      "loading file with nr of windows 1599\n",
      "loading file with nr of windows 1725\n",
      "loading file with nr of windows 1561\n",
      "loading file with nr of windows 1724\n",
      "loading file with nr of windows 1843\n",
      "loading file with nr of windows 1633\n",
      "loading file with nr of windows 1775\n",
      "loading file with nr of windows 1806\n",
      "loading file with nr of windows 1798\n"
     ]
    }
   ],
   "source": [
    "data = load_all_data()\n",
    "labels = load_all_labels()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:08:47.527167383Z",
     "start_time": "2023-06-05T12:08:47.494510204Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({0: 3519, 1: 1127, 2: 8844, 3: 975, 5: 3473, 4: 1310})"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "counted_labels = Counter(labels)\n",
    "counted_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:08:47.527939809Z",
     "start_time": "2023-06-05T12:08:47.514880012Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({0: 3519, 1: 12256, 2: 3473})"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def three_stages_transform(n: int):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    if n == 5:\n",
    "        return 2\n",
    "    return 1\n",
    "\n",
    "\n",
    "labels_3_stages = np.array(list(map(three_stages_transform, labels)))\n",
    "counted_labels_3_stages = Counter(labels_3_stages)\n",
    "counted_labels_3_stages"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "My first CNN model from https://ataspinar.com/2018/12/21/a-guide-for-using-the-wavelet-transform-in-machine-learning/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:08:47.581524621Z",
     "start_time": "2023-06-05T12:08:47.528192701Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "train_size = 4000\n",
    "test_size = 400\n",
    "\n",
    "import keras\n",
    "from keras.layers import Dense, Flatten\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras.models import Sequential\n",
    "from keras.callbacks import History\n",
    "\n",
    "history = History()\n",
    "\n",
    "img_x = 127\n",
    "img_y = 127\n",
    "img_z = 1\n",
    "input_shape = (img_x, img_y, img_z)\n",
    "\n",
    "batch_size = 16\n",
    "num_classes = 3\n",
    "epochs = 10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:08:47.592136919Z",
     "start_time": "2023-06-05T12:08:47.571367118Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "shuffle = np.random.shuffle(np.arange(len(data)))\n",
    "data_shuffled = data[shuffle]\n",
    "labels_shuffled = labels[shuffle]\n",
    "labels_3_stages_shuffled = labels_3_stages[shuffle]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:09:17.483288826Z",
     "start_time": "2023-06-05T12:09:17.479167834Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "scales = range(1, 128)\n",
    "waveletname = 'morl'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-05T12:09:29.257271883Z",
     "start_time": "2023-06-05T12:09:17.890240290Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1000\n",
      "2000\n",
      "3000\n"
     ]
    }
   ],
   "source": [
    "\n",
    "train_data_cwt = np.ndarray(shape=(train_size, 127, 127))\n",
    "test_data_cwt = np.ndarray(shape=(test_size, 127, 127))\n",
    "\n",
    "for ii in range(0, train_size):\n",
    "    if ii % 1000 == 0:\n",
    "        print(ii)\n",
    "    signal = data[ii]\n",
    "    coeff, freq = pywt.cwt(signal, scales, waveletname, 1)\n",
    "    coeff_ = coeff[:, :127]\n",
    "    train_data_cwt[ii] = coeff_\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "100\n",
      "200\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "for ii in range(0, test_size):\n",
    "    if ii % 100 == 0:\n",
    "        print(ii)\n",
    "    signal = data[ii]\n",
    "    coeff, freq = pywt.cwt(signal, scales, waveletname, 1)\n",
    "    coeff_ = coeff[:, :127]\n",
    "    test_data_cwt[ii] = coeff_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-06-06 13:26:26.915655: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:26.933839: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:26.934031: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:26.935103: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:26.935257: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:26.935397: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:27.461665: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:27.461850: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:27.462006: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2023-06-06 13:26:27.462121: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 6270 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 2070, pci bus id: 0000:1d:00.0, compute capability: 7.5\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "model.add(Conv2D(32, kernel_size=(5, 5), strides=(1, 1),\n",
    "                 activation='relu',\n",
    "                 input_shape=input_shape))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n",
    "model.add(Conv2D(64, (5, 5), activation='relu'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(1000, activation='relu'))\n",
    "model.add(Dense(num_classes, activation='softmax'))\n",
    "\n",
    "model.compile(loss=keras.losses.categorical_crossentropy,\n",
    "              optimizer=keras.optimizers.Adam(),\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 123, 123, 32)      832       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 61, 61, 32)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 57, 57, 64)        51264     \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 28, 28, 64)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 50176)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 1000)              50177000  \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 3)                 3003      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 50,232,099\n",
      "Trainable params: 50,232,099\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = train_data_cwt\n",
    "x_test = test_data_cwt\n",
    "y_train = labels_3_stages[:train_size]\n",
    "y_test = labels_3_stages[-test_size:]\n",
    "\n",
    "y_train = keras.utils.to_categorical(y_train,num_classes)\n",
    "y_test = keras.utils.to_categorical(y_test,num_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-06-06 13:26:29.700639: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:424] Loaded cuDNN version 8901\n",
      "2023-06-06 13:26:30.616093: I tensorflow/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n",
      "2023-06-06 13:26:30.617127: I tensorflow/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n",
      "2023-06-06 13:26:30.617147: W tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.cc:109] Couldn't get ptxas version : FAILED_PRECONDITION: Couldn't get ptxas/nvlink version string: INTERNAL: Couldn't invoke ptxas --version\n",
      "2023-06-06 13:26:30.618218: I tensorflow/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n",
      "2023-06-06 13:26:30.618262: W tensorflow/compiler/xla/stream_executor/gpu/redzone_allocator.cc:317] INTERNAL: Failed to launch ptxas\n",
      "Relying on driver to perform ptx compilation. \n",
      "Modify $PATH to customize ptxas location.\n",
      "This message will be only logged once.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 7s 13ms/step - loss: 0.9698 - accuracy: 0.5393 - val_loss: 1.0033 - val_accuracy: 0.6775\n",
      "Epoch 2/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9606 - accuracy: 0.5490 - val_loss: 0.9688 - val_accuracy: 0.6775\n",
      "Epoch 3/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9607 - accuracy: 0.5490 - val_loss: 0.9727 - val_accuracy: 0.6775\n",
      "Epoch 4/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9580 - accuracy: 0.5490 - val_loss: 0.9670 - val_accuracy: 0.6775\n",
      "Epoch 5/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9570 - accuracy: 0.5490 - val_loss: 0.9740 - val_accuracy: 0.6775\n",
      "Epoch 6/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9565 - accuracy: 0.5490 - val_loss: 0.9780 - val_accuracy: 0.6775\n",
      "Epoch 7/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9573 - accuracy: 0.5490 - val_loss: 0.9721 - val_accuracy: 0.6775\n",
      "Epoch 8/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9558 - accuracy: 0.5490 - val_loss: 0.9678 - val_accuracy: 0.6775\n",
      "Epoch 9/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9553 - accuracy: 0.5490 - val_loss: 0.9649 - val_accuracy: 0.6775\n",
      "Epoch 10/10\n",
      "250/250 [==============================] - 3s 12ms/step - loss: 0.9555 - accuracy: 0.5490 - val_loss: 0.9548 - val_accuracy: 0.6775\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7fc6c3951940>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(x_train, y_train,\n",
    "          batch_size=batch_size,\n",
    "          epochs=epochs,\n",
    "          verbose=1,\n",
    "          validation_data=(x_test, y_test),\n",
    "          callbacks=[history])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 0.9558569192886353, Train accuracy: 0.5490000247955322\n",
      "Test loss: 0.9548448920249939, Test accuracy: 0.6775000095367432\n"
     ]
    }
   ],
   "source": [
    "train_score = model.evaluate(x_train, y_train, verbose=0)\n",
    "print('Train loss: {}, Train accuracy: {}'.format(train_score[0], train_score[1]))\n",
    "test_score = model.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test loss: {}, Test accuracy: {}'.format(test_score[0], test_score[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axarr = plt.subplots(figsize=(12,6), ncols=2)\n",
    "axarr[0].plot(range(1, 11), history.history['accuracy'], label='train score')\n",
    "axarr[0].plot(range(1, 11), history.history['val_accuracy'], label='test score')\n",
    "axarr[0].set_xlabel('Number of Epochs', fontsize=18)\n",
    "axarr[0].set_ylabel('Accuracy', fontsize=18)\n",
    "axarr[0].set_ylim([0,1])\n",
    "axarr[1].plot(range(1, 11), history.history['accuracy'], label='train score')\n",
    "axarr[1].plot(range(1, 11), history.history['val_accuracy'], label='test score')\n",
    "axarr[1].set_xlabel('Number of Epochs', fontsize=18)\n",
    "axarr[1].set_ylabel('Accuracy', fontsize=18)\n",
    "axarr[1].set_ylim([0.9,1])\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [0.969843327999115,\n",
       "  0.9606369137763977,\n",
       "  0.9606726169586182,\n",
       "  0.9580044150352478,\n",
       "  0.9570040702819824,\n",
       "  0.9565365314483643,\n",
       "  0.9572973847389221,\n",
       "  0.9557863473892212,\n",
       "  0.9552872180938721,\n",
       "  0.9555025100708008],\n",
       " 'accuracy': [0.5392500162124634,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322,\n",
       "  0.5490000247955322],\n",
       " 'val_loss': [1.0032552480697632,\n",
       "  0.9687631130218506,\n",
       "  0.97272127866745,\n",
       "  0.9669603109359741,\n",
       "  0.9740071296691895,\n",
       "  0.9779520630836487,\n",
       "  0.9721001386642456,\n",
       "  0.9677794575691223,\n",
       "  0.9648762345314026,\n",
       "  0.954845130443573],\n",
       " 'val_accuracy': [0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432,\n",
       "  0.6775000095367432]}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "test_data_cwt"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
